package com.c6906.vdam.dps.service.impl;

import com.alibaba.fastjson.JSON;
import com.c6906.vdam.dps.common.DataStatusEnum;
import com.c6906.vdam.dps.common.DateUtils;
import com.c6906.vdam.dps.common.IDGenUtil;
import com.c6906.vdam.dps.config.redis.RedisUtils;
import com.c6906.vdam.dps.dao.TerminalHistoryDetailsDAO;
import com.c6906.vdam.dps.entity.*;
import com.c6906.vdam.dps.service.TerminalHistoryDetailsService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Author : TAOHUIQI
 * @Date: 2024/7/28 12:29
 * @Description:
 */
@Service
public class TerminalHistoryDetailsServiceImpl implements TerminalHistoryDetailsService {

    private static final Logger logger = LoggerFactory.getLogger(TerminalHistoryDetailsServiceImpl.class);

    @Autowired
    TerminalHistoryDetailsDAO terminalHistoryDetailsDAO;

    @Autowired
    RedisUtils redisUtils;

    @Override
    public void handleTerminalHistoryDetails(List<TerminalData> dataList) {
        //定义一个新增异常详情addErrorDetailsList和更新异常详情updateErrorDetailsList
        //List<TerminalErrorHistoryDetails> addErrorDetailsList = new ArrayList<>();
        //List<TerminalErrorHistoryDetails> updateErrorDetailsList = new ArrayList<>();
        //定义一个新增告警详情addWarningDetailsList和更新告警详情updateWarningDetailsList
        List<TerminalWarningHistoryDetails> addWarningDetailsList = new ArrayList<>();
        List<TerminalWarningHistoryDetails> updateWarningDetailsList = new ArrayList<>();
        if (!CollectionUtils.isEmpty(dataList)) {
            for (TerminalData terminalData : dataList) {
                //根据设备号从redis获取最新的两条记录
                List<String> historyList = redisUtils.getLastDatasForHistory(terminalData.getTerminalSn());
                //logger.info("getLastDatasForHistory===={}",JSON.toJSONString(historyList));
                TerminalData terminalPreData = new TerminalData();
                //获取上一条数据
                if (historyList.size() > 1) {
                    if (!StringUtils.isEmpty(historyList.get(1))) {
                        //JSONString转为对象
                        terminalPreData = JSON.parseObject(historyList.get(1), TerminalData.class);
                    }
                }
                //异常逻辑处理
                //dealWithErrorInfo(terminalData, terminalPreData, addErrorDetailsList, updateErrorDetailsList);
                //告警逻辑处理
                dealWithWarningInfo(terminalData, terminalPreData, addWarningDetailsList, updateWarningDetailsList);
            }
            //入库处理
            //if (!CollectionUtils.isEmpty(addErrorDetailsList)) {
                //新增异常详情
                //terminalHistoryDetailsDAO.batchInsertErrorHistoryDetails(addErrorDetailsList);
            //}
            //if (!CollectionUtils.isEmpty(updateErrorDetailsList)) {
                //更新异常详情
                //terminalHistoryDetailsDAO.batchUpdateErrorHistoryDetails(updateErrorDetailsList);
            //}
            if (!CollectionUtils.isEmpty(addWarningDetailsList)) {
                //新增告警详情
                terminalHistoryDetailsDAO.batchInsertWarningHistoryDetails(addWarningDetailsList);
            }
            if (!CollectionUtils.isEmpty(updateWarningDetailsList)) {
                //更新告警详情
                terminalHistoryDetailsDAO.batchUpdateWarningHistoryDetails(updateWarningDetailsList);
            }
        }
    }

    private void dealWithErrorInfo(TerminalData terminalData, TerminalData terminalPreData, List<TerminalErrorHistoryDetails> addErrorDetailsList, List<TerminalErrorHistoryDetails> updateErrorDetailsList) {
        //异常详情表处理
        List<TerminalErrorHistoryDetails> errorHistoryList = terminalHistoryDetailsDAO.queryErrorHistoryDetailNoStopList(terminalData.getTerminalSn());
        List<TerminalErrorHistoryDetails> errorHistorys1 = errorHistoryList.stream().filter(p -> p.getErrorType() == DataStatusEnum.ANT_OPEN.getCode()).collect(Collectors.toList());
        List<TerminalErrorHistoryDetails> errorHistorys2 = errorHistoryList.stream().filter(p -> p.getErrorType() == DataStatusEnum.ANT_SHORT.getCode()).collect(Collectors.toList());
        List<TerminalErrorHistoryDetails> errorHistorys3 = errorHistoryList.stream().filter(p -> p.getErrorType() == DataStatusEnum.NO_VOL.getCode()).collect(Collectors.toList());

        //异常状态判断-GNSS天线开路
        if (!terminalData.getTerminalAntOpen().equals(terminalPreData.getTerminalAntOpen())) {
            //如果状态是1变为0
            if (terminalData.getTerminalAntOpen().equals("0") && terminalPreData.getTerminalAntOpen().equals("1")) {
                //如果原来的异常详情表存在异常数据(可能存在多条)-则关闭该异常，更新异常结束时间，异常持续时间和经纬度信息
                if (!CollectionUtils.isEmpty(errorHistorys1)) {
                    for (TerminalErrorHistoryDetails errorHistoryDetails : errorHistorys1) {
                        if (null != errorHistoryDetails) {
                            errorHistoryDetails.setErrorStopTime(terminalData.getTerminalTime());
                            //计算异常持续时间
                            errorHistoryDetails.setErrorLastTime(DateUtils.calculateTimeDiff(errorHistoryDetails.getErrorStartTime(), errorHistoryDetails.getErrorStopTime()));
                            errorHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            errorHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            errorHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateErrorDetailsList.add(errorHistoryDetails);
                        }
                    }
                }
                //如果原来的异常详情表不存在异常数据-说明没有异常需要处理，跳过
            }
            // 如果状态是0变为1，
            if (terminalData.getTerminalAntOpen().equals("1") && terminalPreData.getTerminalAntOpen().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(errorHistorys1)) {
                    String antOpenId = IDGenUtil.getUUIDWithoutDash();
                    TerminalErrorHistoryDetails terminalErrorHistoryDetails2 = new TerminalErrorHistoryDetails();
                    generateAddTerminalErrorHistoryDetails(terminalData, terminalErrorHistoryDetails2, DataStatusEnum.ANT_OPEN.getCode(), DataStatusEnum.ANT_OPEN.getName(), antOpenId);
                    //添加到新增异常详情addErrorDetailsList
                    addErrorDetailsList.add(terminalErrorHistoryDetails2);
                }
                //根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }

        //异常状态判断-GNSS天线短路
        if (!terminalData.getTerminalAntShort().equals(terminalPreData.getTerminalAntShort())) {
            //如果状态是1变为0
            if (terminalData.getTerminalAntShort().equals("0") && terminalPreData.getTerminalAntShort().equals("1")) {
                //如果原来的异常详情表存在异常数据(可能存在多条)-则关闭该异常，更新异常结束时间，异常持续时间和经纬度信息
                if (!CollectionUtils.isEmpty(errorHistorys2)) {
                    for (TerminalErrorHistoryDetails errorHistoryDetails : errorHistorys2) {
                        if (null != errorHistoryDetails) {
                            errorHistoryDetails.setErrorStopTime(terminalData.getTerminalTime());
                            //计算异常持续时间
                            errorHistoryDetails.setErrorLastTime(DateUtils.calculateTimeDiff(errorHistoryDetails.getErrorStartTime(), errorHistoryDetails.getErrorStopTime()));
                            errorHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            errorHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            errorHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateErrorDetailsList.add(errorHistoryDetails);
                        }
                    }
                }
                //如果原来的异常详情表不存在异常数据-说明没有异常需要处理，跳过
            }
            // 如果状态是0变为1，
            if (terminalData.getTerminalAntShort().equals("1") && terminalPreData.getTerminalAntShort().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(errorHistorys2)) {
                    String antShortId = IDGenUtil.getUUIDWithoutDash();
                    TerminalErrorHistoryDetails terminalErrorHistoryDetails2 = new TerminalErrorHistoryDetails();
                    generateAddTerminalErrorHistoryDetails(terminalData, terminalErrorHistoryDetails2, DataStatusEnum.ANT_SHORT.getCode(), DataStatusEnum.ANT_SHORT.getName(), antShortId);
                    //添加到新增异常详情addErrorDetailsList
                    addErrorDetailsList.add(terminalErrorHistoryDetails2);
                }
                //根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }

        //异常状态判断-模块掉电
        if (!terminalData.getTerminalNoVol().equals(terminalPreData.getTerminalNoVol())) {
            //如果状态是1变为0
            if (terminalData.getTerminalNoVol().equals("0") && terminalPreData.getTerminalNoVol().equals("1")) {
                //如果原来的异常详情表存在异常数据(可能存在多条)-则关闭该异常，更新异常结束时间，异常持续时间和经纬度信息
                if (!CollectionUtils.isEmpty(errorHistorys3)) {
                    for (TerminalErrorHistoryDetails errorHistoryDetails : errorHistorys3) {
                        if (null != errorHistoryDetails) {
                            errorHistoryDetails.setErrorStopTime(terminalData.getTerminalTime());
                            //计算异常持续时间
                            errorHistoryDetails.setErrorLastTime(DateUtils.calculateTimeDiff(errorHistoryDetails.getErrorStartTime(), errorHistoryDetails.getErrorStopTime()));
                            errorHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            errorHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            errorHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateErrorDetailsList.add(errorHistoryDetails);
                        }
                    }
                }
                //如果原来的异常详情表不存在异常数据-说明没有异常需要处理，跳过
            }
            // 如果状态是0变为1
            if (terminalData.getTerminalNoVol().equals("1") && terminalPreData.getTerminalNoVol().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(errorHistorys3)) {
                    String antShortId = IDGenUtil.getUUIDWithoutDash();
                    TerminalErrorHistoryDetails terminalErrorHistoryDetails3 = new TerminalErrorHistoryDetails();
                    generateAddTerminalErrorHistoryDetails(terminalData, terminalErrorHistoryDetails3, DataStatusEnum.NO_VOL.getCode(), DataStatusEnum.NO_VOL.getName(), antShortId);
                    //添加到新增异常详情addErrorDetailsList
                    addErrorDetailsList.add(terminalErrorHistoryDetails3);
                }
                //根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }
    }

    private void dealWithWarningInfo(TerminalData terminalData, TerminalData terminalPreData, List<TerminalWarningHistoryDetails> addWarningDetailsList, List<TerminalWarningHistoryDetails> updateWarningDetailsList) {
        //告警详情表处理
        List<TerminalWarningHistoryDetails> warningHistoryList = terminalHistoryDetailsDAO.queryWarningHistoryDetailNoStopList(terminalData.getTerminalSn());
        List<TerminalWarningHistoryDetails> warningrHistorys1 = warningHistoryList.stream().filter(p -> p.getWarningType() == DataStatusEnum.ANT_OPEN.getCode()).collect(Collectors.toList());
        List<TerminalWarningHistoryDetails> warningHistorys2 = warningHistoryList.stream().filter(p -> p.getWarningType() == DataStatusEnum.ANT_SHORT.getCode()).collect(Collectors.toList());
        List<TerminalWarningHistoryDetails> warningHistorys3 = warningHistoryList.stream().filter(p -> p.getWarningType() == DataStatusEnum.NO_VOL.getCode()).collect(Collectors.toList());
        //在线和离线单独走PushConsumer消费流程处理
        List<TerminalWarningHistoryDetails> warningHistorys5 = warningHistoryList.stream().filter(p -> p.getWarningType() == DataStatusEnum.OVER_SPEED.getCode()).collect(Collectors.toList());
        List<TerminalWarningHistoryDetails> warningHistorys6 = warningHistoryList.stream().filter(p -> p.getWarningType() == DataStatusEnum.TIRED_DRIVE.getCode()).collect(Collectors.toList());
        List<TerminalWarningHistoryDetails> warningHistorys7 = warningHistoryList.stream().filter(p -> p.getWarningType() == DataStatusEnum.GNSS_ERROR.getCode()).collect(Collectors.toList());
        List<TerminalWarningHistoryDetails> warningHistorys8 = warningHistoryList.stream().filter(p -> p.getWarningType() == DataStatusEnum.UNDER_VOL.getCode()).collect(Collectors.toList());


        //告警状态判断-GNSS天线开路
        if (!terminalData.getTerminalAntOpen().equals(terminalPreData.getTerminalAntOpen())) {
            //如果状态是1变为0
            if (terminalData.getTerminalAntOpen().equals("0") && terminalPreData.getTerminalAntOpen().equals("1")) {
                //如果原来的异常详情表存在异常数据(可能存在多条)-则关闭该异常，更新异常结束时间，异常持续时间和经纬度信息
                if (!CollectionUtils.isEmpty(warningrHistorys1)) {
                    for (TerminalWarningHistoryDetails warningHistoryDetails : warningrHistorys1) {
                        if (null != warningHistoryDetails) {
                            warningHistoryDetails.setWarningStopTime(terminalData.getTerminalTime());
                            //计算异常持续时间
                            warningHistoryDetails.setWarningLastTime(DateUtils.calculateTimeDiff(warningHistoryDetails.getWarningStartTime(), warningHistoryDetails.getWarningStopTime()));
                            warningHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            warningHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            warningHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateWarningDetailsList.add(warningHistoryDetails);
                        }
                    }
                }
                //如果原来的异常详情表不存在异常数据-说明没有异常需要处理，跳过
            }
            // 如果状态是0变为1，
            if (terminalData.getTerminalAntOpen().equals("1") && terminalPreData.getTerminalAntOpen().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(warningrHistorys1)) {
                    String antOpenId = IDGenUtil.getUUIDWithoutDash();
                    TerminalWarningHistoryDetails terminalWarningHistoryDetails1 = new TerminalWarningHistoryDetails();
                    generateAddTerminalWarningHistoryDetails(terminalData, terminalWarningHistoryDetails1, DataStatusEnum.ANT_OPEN.getCode(), DataStatusEnum.ANT_OPEN.getName(), antOpenId);
                    //添加到新增异常详情addErrorDetailsList
                    addWarningDetailsList.add(terminalWarningHistoryDetails1);
                }
                //根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }

        //异常状态判断-GNSS天线短路
        if (!terminalData.getTerminalAntShort().equals(terminalPreData.getTerminalAntShort())) {
            //如果状态是1变为0
            if (terminalData.getTerminalAntShort().equals("0") && terminalPreData.getTerminalAntShort().equals("1")) {
                //如果原来的异常详情表存在异常数据(可能存在多条)-则关闭该异常，更新异常结束时间，异常持续时间和经纬度信息
                if (!CollectionUtils.isEmpty(warningHistorys2)) {
                    for (TerminalWarningHistoryDetails warningHistoryDetails : warningHistorys2) {
                        if (null != warningHistoryDetails) {
                            warningHistoryDetails.setWarningStopTime(terminalData.getTerminalTime());
                            //计算异常持续时间
                            warningHistoryDetails.setWarningLastTime(DateUtils.calculateTimeDiff(warningHistoryDetails.getWarningStartTime(), warningHistoryDetails.getWarningStopTime()));
                            warningHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            warningHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            warningHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateWarningDetailsList.add(warningHistoryDetails);
                        }
                    }
                }
                //如果原来的异常详情表不存在异常数据-说明没有异常需要处理，跳过
            }
            // 如果状态是0变为1，
            if (terminalData.getTerminalAntShort().equals("1") && terminalPreData.getTerminalAntShort().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(warningHistorys2)) {
                    String antShortId = IDGenUtil.getUUIDWithoutDash();
                    TerminalWarningHistoryDetails terminalWarningHistoryDetails2 = new TerminalWarningHistoryDetails();
                    generateAddTerminalWarningHistoryDetails(terminalData, terminalWarningHistoryDetails2, DataStatusEnum.ANT_SHORT.getCode(), DataStatusEnum.ANT_SHORT.getName(), antShortId);
                    //添加到新增异常详情addErrorDetailsList
                    addWarningDetailsList.add(terminalWarningHistoryDetails2);
                }
                //根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }

        //异常状态判断-模块掉电
        if (!terminalData.getTerminalNoVol().equals(terminalPreData.getTerminalNoVol())) {
            //如果状态是1变为0
            if (terminalData.getTerminalNoVol().equals("0") && terminalPreData.getTerminalNoVol().equals("1")) {
                //如果原来的异常详情表存在异常数据(可能存在多条)-则关闭该异常，更新异常结束时间，异常持续时间和经纬度信息
                if (!CollectionUtils.isEmpty(warningHistorys3)) {
                    for (TerminalWarningHistoryDetails warningHistoryDetails : warningHistorys3) {
                        if (null != warningHistoryDetails) {
                            warningHistoryDetails.setWarningStopTime(terminalData.getTerminalTime());
                            //计算异常持续时间
                            warningHistoryDetails.setWarningLastTime(DateUtils.calculateTimeDiff(warningHistoryDetails.getWarningStartTime(), warningHistoryDetails.getWarningStopTime()));
                            warningHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            warningHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            warningHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateWarningDetailsList.add(warningHistoryDetails);
                        }
                    }
                }
                //如果原来的异常详情表不存在异常数据-说明没有异常需要处理，跳过
            }
            // 如果状态是0变为1
            if (terminalData.getTerminalNoVol().equals("1") && terminalPreData.getTerminalNoVol().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(warningHistorys3)) {
                    String antShortId = IDGenUtil.getUUIDWithoutDash();
                    TerminalWarningHistoryDetails terminalWarningHistoryDetails3 = new TerminalWarningHistoryDetails();
                    generateAddTerminalWarningHistoryDetails(terminalData, terminalWarningHistoryDetails3, DataStatusEnum.NO_VOL.getCode(), DataStatusEnum.NO_VOL.getName(), antShortId);
                    //添加到新增异常详情addErrorDetailsList
                    addWarningDetailsList.add(terminalWarningHistoryDetails3);
                }
                //根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }

        //告警状态判断-超速驾驶
        if (!terminalData.getTerminalOverSpeed().equals(terminalPreData.getTerminalOverSpeed())) {
            //如果状态是1变为0
            if (terminalData.getTerminalOverSpeed().equals("0") && terminalPreData.getTerminalOverSpeed().equals("1")) {
                if (!CollectionUtils.isEmpty(warningHistorys5)) {
                    for (TerminalWarningHistoryDetails warningHistoryDetails : warningHistorys5) {
                        if (null != warningHistoryDetails) {
                            warningHistoryDetails.setWarningStopTime(terminalData.getTerminalTime());
                            //计算告警持续时间
                            warningHistoryDetails.setWarningLastTime(DateUtils.calculateTimeDiff(warningHistoryDetails.getWarningStartTime(), warningHistoryDetails.getWarningStopTime()));
                            warningHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            warningHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            warningHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateWarningDetailsList.add(warningHistoryDetails);
                        }
                    }
                }
                //如果原来的告警详情表不存在异常数据-说明没有告警需要处理，跳过
            }
            // 如果状态是0变为1
            if (terminalData.getTerminalOverSpeed().equals("1") && terminalPreData.getTerminalOverSpeed().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(warningHistorys5)) {
                    String overSpeedId = IDGenUtil.getUUIDWithoutDash();
                    TerminalWarningHistoryDetails terminalWarningHistoryDetails5 = new TerminalWarningHistoryDetails();
                    generateAddTerminalWarningHistoryDetails(terminalData, terminalWarningHistoryDetails5, DataStatusEnum.OVER_SPEED.getCode(), DataStatusEnum.OVER_SPEED.getName(), overSpeedId);
                    //添加到新增异常详情addErrorDetailsList
                    addWarningDetailsList.add(terminalWarningHistoryDetails5);
                }
                //根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }

        //告警状态判断-疲劳驾驶
        if (!terminalData.getTerminalTiredDrive().equals(terminalPreData.getTerminalTiredDrive())) {
            //如果状态是1变为0
            if (terminalData.getTerminalTiredDrive().equals("0") && terminalPreData.getTerminalTiredDrive().equals("1")) {
                if (!CollectionUtils.isEmpty(warningHistorys6)) {
                    for (TerminalWarningHistoryDetails warningHistoryDetails : warningHistorys6) {
                        if (null != warningHistoryDetails) {
                            warningHistoryDetails.setWarningStopTime(terminalData.getTerminalTime());
                            //计算告警持续时间
                            warningHistoryDetails.setWarningLastTime(DateUtils.calculateTimeDiff(warningHistoryDetails.getWarningStartTime(), warningHistoryDetails.getWarningStopTime()));
                            warningHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            warningHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            warningHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateWarningDetailsList.add(warningHistoryDetails);
                        }
                    }
                }
                //如果原来的告警详情表不存在异常数据-说明没有告警需要处理，跳过
            }
            // 如果状态是0变为1
            if (terminalData.getTerminalTiredDrive().equals("1") && terminalPreData.getTerminalTiredDrive().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(warningHistorys6)) {
                    String overSpeedId = IDGenUtil.getUUIDWithoutDash();
                    TerminalWarningHistoryDetails terminalWarningHistoryDetails6 = new TerminalWarningHistoryDetails();
                    generateAddTerminalWarningHistoryDetails(terminalData, terminalWarningHistoryDetails6, DataStatusEnum.TIRED_DRIVE.getCode(), DataStatusEnum.TIRED_DRIVE.getName(), overSpeedId);
                    //添加到新增异常详情addErrorDetailsList
                    addWarningDetailsList.add(terminalWarningHistoryDetails6);
                }
                //根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }

        //告警状态判断-GNSS模块异常状态
        if (!terminalData.getTerminalGnssError().equals(terminalPreData.getTerminalGnssError())) {
            //如果状态是1变为0
            if (terminalData.getTerminalGnssError().equals("0") && terminalPreData.getTerminalGnssError().equals("1")) {
                if (!CollectionUtils.isEmpty(warningHistorys7)) {
                    for (TerminalWarningHistoryDetails warningHistoryDetails : warningHistorys7) {
                        if (null != warningHistoryDetails) {
                            warningHistoryDetails.setWarningStopTime(terminalData.getTerminalTime());
                            //计算告警持续时间
                            warningHistoryDetails.setWarningLastTime(DateUtils.calculateTimeDiff(warningHistoryDetails.getWarningStartTime(), warningHistoryDetails.getWarningStopTime()));
                            warningHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            warningHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            warningHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateWarningDetailsList.add(warningHistoryDetails);
                        }
                    }
                }
                //如果原来的告警详情表不存在异常数据-说明没有告警需要处理，跳过
            }
            // 如果状态是0变为1
            if (terminalData.getTerminalGnssError().equals("1") && terminalPreData.getTerminalGnssError().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(warningHistorys7)) {
                    String overSpeedId = IDGenUtil.getUUIDWithoutDash();
                    TerminalWarningHistoryDetails terminalWarningHistoryDetails7 = new TerminalWarningHistoryDetails();
                    generateAddTerminalWarningHistoryDetails(terminalData, terminalWarningHistoryDetails7, DataStatusEnum.GNSS_ERROR.getCode(), DataStatusEnum.GNSS_ERROR.getName(), overSpeedId);
                    //添加到新增异常详情addErrorDetailsList
                    addWarningDetailsList.add(terminalWarningHistoryDetails7);
                }
                //根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }

        //告警状态判断-离线状态
        if (!terminalData.getTerminalUnderVol().equals(terminalPreData.getTerminalUnderVol())) {
            //如果状态是1变为0
            if (terminalData.getTerminalUnderVol().equals("0") && terminalPreData.getTerminalUnderVol().equals("1")) {
                if (!CollectionUtils.isEmpty(warningHistorys8)) {
                    for (TerminalWarningHistoryDetails warningHistoryDetails : warningHistorys8) {
                        if (null != warningHistoryDetails) {
                            warningHistoryDetails.setWarningStopTime(terminalData.getTerminalTime());
                            //计算告警持续时间
                            warningHistoryDetails.setWarningLastTime(DateUtils.calculateTimeDiff(warningHistoryDetails.getWarningStartTime(), warningHistoryDetails.getWarningStopTime()));
                            warningHistoryDetails.setStopLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
                            warningHistoryDetails.setStopLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
                            warningHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
                            updateWarningDetailsList.add(warningHistoryDetails);
                        }
                    }
                }
                //如果原来的告警详情表不存在异常数据-说明没有告警需要处理，跳过
            }
            // 如果状态是0变为1
            if (terminalData.getTerminalUnderVol().equals("1") && terminalPreData.getTerminalUnderVol().equals("0")) {
                // 根据设备号查询数据库是否存在异常结束时间为空,如果不存在，则新增一条异常
                if (CollectionUtils.isEmpty(warningHistorys8)) {
                    String overSpeedId = IDGenUtil.getUUIDWithoutDash();
                    TerminalWarningHistoryDetails terminalWarningHistoryDetails8 = new TerminalWarningHistoryDetails();
                    generateAddTerminalWarningHistoryDetails(terminalData, terminalWarningHistoryDetails8, DataStatusEnum.UNDER_VOL.getCode(), DataStatusEnum.UNDER_VOL.getName(), overSpeedId);
                    //添加到新增异常详情addErrorDetailsList
                    addWarningDetailsList.add(terminalWarningHistoryDetails8);
                }
                //根据设备号查询数据库是否存在异常结束时间为空，如果存在，异常已经存在，跳过
            }
        }
    }

    private TerminalErrorHistoryDetails generateAddTerminalErrorHistoryDetails(TerminalData terminalData, TerminalErrorHistoryDetails terminalErrorHistoryDetails, int errorType, String errorTypeName, String uuid) {
        terminalErrorHistoryDetails.setId(uuid);
        terminalErrorHistoryDetails.setTerminalSn(terminalData.getTerminalSn());
        terminalErrorHistoryDetails.setErrorStartTime(terminalData.getTerminalTime());
        terminalErrorHistoryDetails.setErrorType(errorType);
        terminalErrorHistoryDetails.setErrorTypeName(errorTypeName);
        terminalErrorHistoryDetails.setStartLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
        terminalErrorHistoryDetails.setStartLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
        terminalErrorHistoryDetails.setRegionCode(terminalData.getRegionCode());
        terminalErrorHistoryDetails.setRegionName(terminalData.getRegionName());
        terminalErrorHistoryDetails.setVehiclesCode(terminalData.getVehiclesCode());
        terminalErrorHistoryDetails.setVehPlateNum(terminalData.getVehPlateNum());
        terminalErrorHistoryDetails.setOwnUnitId(StringUtils.isEmpty(terminalData.getOwnUnitId()) ? 0L : Long.parseLong(terminalData.getOwnUnitId()));
        terminalErrorHistoryDetails.setOwnUnitName(terminalData.getOwnUnitName());
        terminalErrorHistoryDetails.setUseUnitId(StringUtils.isEmpty(terminalData.getUseUnitId()) ? 0L : Long.parseLong(terminalData.getUseUnitId()));
        terminalErrorHistoryDetails.setUseUnitName(terminalData.getUseUnitName());
        terminalErrorHistoryDetails.setPlateColorName(terminalData.getPlateColorName());
        terminalErrorHistoryDetails.setDataCreate(DateUtils.dateToStr(new Date()));
        terminalErrorHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
        return terminalErrorHistoryDetails;
    }

    private TerminalWarningHistoryDetails generateAddTerminalWarningHistoryDetails(TerminalData terminalData, TerminalWarningHistoryDetails terminalWarningHistoryDetails, int warningType, String warningTypeName, String uuid) {
        terminalWarningHistoryDetails.setId(uuid);
        terminalWarningHistoryDetails.setTerminalSn(terminalData.getTerminalSn());
        terminalWarningHistoryDetails.setWarningStartTime(terminalData.getTerminalTime());
        terminalWarningHistoryDetails.setWarningType(warningType);
        terminalWarningHistoryDetails.setWarningTypeName(warningTypeName);
        terminalWarningHistoryDetails.setStartLat(DateUtils.strToBigDecimal(terminalData.getLatitude()));
        terminalWarningHistoryDetails.setStartLong(DateUtils.strToBigDecimal(terminalData.getLongitude()));
        terminalWarningHistoryDetails.setRegionCode(terminalData.getRegionCode());
        terminalWarningHistoryDetails.setRegionName(terminalData.getRegionName());
        terminalWarningHistoryDetails.setVehiclesCode(terminalData.getVehiclesCode());
        terminalWarningHistoryDetails.setVehPlateNum(terminalData.getVehPlateNum());
        terminalWarningHistoryDetails.setOwnUnitId(StringUtils.isEmpty(terminalData.getOwnUnitId()) ? 0L : Long.parseLong(terminalData.getOwnUnitId()));
        terminalWarningHistoryDetails.setOwnUnitName(terminalData.getOwnUnitName());
        terminalWarningHistoryDetails.setUseUnitId(StringUtils.isEmpty(terminalData.getUseUnitId()) ? 0L : Long.parseLong(terminalData.getUseUnitId()));
        terminalWarningHistoryDetails.setUseUnitName(terminalData.getUseUnitName());
        terminalWarningHistoryDetails.setPlateColorName(terminalData.getPlateColorName());
        terminalWarningHistoryDetails.setDataCreate(DateUtils.dateToStr(new Date()));
        terminalWarningHistoryDetails.setDataUpdate(DateUtils.dateToStr(new Date()));
        return terminalWarningHistoryDetails;
    }
}
